package com.lxh.config.utils;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


/**
 * @ClassName: ListUtils
 * @Author: lxh
 * @Description: java8 list常用的新特性
 * @Date: 2022/8/3 15:38
 */
@Data
public class ListUtils {

    private String outerId;

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    static class User {

        private String name;

        private Integer score;
    }

    public static void main(String[] args) {
        //获取测试对象
        List<User> userList = getUserList();
        System.out.println("==============list转map<属性，对象>==============");
        listToMapObject(userList).forEach((key, value) -> System.out.println(key + ": " + value));
        System.out.println("==============list转map<属性，属性>==============");
        listToMap(userList).forEach((key, value) -> System.out.println(key + ": " + value));
        System.out.println("==============list对象获取某一个属性的集合==============");
        getIdList(userList).forEach(System.out::println);
        System.out.println("==============使用map方法获取list数据中的name的长度==============");
        getNameLength(userList).forEach(System.out::println);
        System.out.println("==============从集合中过滤出来符合条件的元素==============");
        getUserListBy(userList).forEach(System.out::println);
        System.out.println("==============集合去重==============");
        distinct(userList).forEach(System.out::println);
        System.out.println("==============排序==============");
        sort(userList).forEach(System.out::println);
        System.out.println("==============操作属性==============");
        doScore(userList).forEach(System.out::println);
        System.out.println("==============计算最高分==============");
        System.out.println("最高分：" + getMaxScore(userList));
        System.out.println("==============计算最低分==============");
        System.out.println("最低分：" + getMinScore(userList));
        System.out.println("==============计算总分==============");
        System.out.println("总分：" + getTotalScore(userList));
        System.out.println("==============计算平均分==============");
        System.out.println("平均分：" + getAvgScore(userList));
        System.out.println("==============清空对象list集合中的某个属性的值并返回结果==============");
        cleanBy(userList).forEach(System.out::println);
        System.out.println("==============获取list集合中前三个元素,组成新的集合==============");
        getLimit(userList).forEach(System.out::println);
        System.out.println("==============跳过list集合中前三个元素,剩余的元素组成新的集合==============");
        skip(userList).forEach(System.out::println);
        System.out.println("==============groupBy分组==============");
        groupBy(userList).forEach((key, value) -> System.out.println(key + ": " + value));
        System.out.println("==============list去重==============");
        distinctList(userList).forEach(System.out::println);
    }

    /**
     * 获取测试数据
     */
    private static List<User> getUserList(){
        List<User> list = new ArrayList<>();
        list.add(new User("张三", 100));
        list.add(new User("张三", 100));
        list.add(new User("李四", 80));
        list.add(new User("王五", 60));
        return list;
    }

    /**
     * list转map<属性，对象>, (key1, key2) -> key1若出现重复的key以第一次出现的数据为准
     */
    private static Map<String, User> listToMapObject(List<User> userList){
        return userList.stream().collect(Collectors.toMap(User::getName, user -> user, (key1, key2) -> key1));
    }

    /**
     * list转map<属性，属性>
     */
    private static Map<String, Integer> listToMap(List<User> userList){
        return userList.stream().collect(Collectors.toMap(User::getName, User::getScore, (key1, key2) -> key1));
    }

    /**
     * list对象获取某一个属性的集合
     */
    private static List<String> getIdList(List<User> userList){
        return userList.stream().map(User::getName).collect(Collectors.toList());
    }

    /**
     * 使用map方法获取list数据中的name的长度
     */
    private static List<Integer> getNameLength(List<User> userList){
        return userList.stream().map(User::getName).map(String::length).collect(Collectors.toList());
    }

    /**
     * 从集合中过滤出来符合条件的元素
     */
    private static List<User> getUserListBy(List<User> userList) {
        return userList.stream().filter(user -> user.getScore() > 60).collect(Collectors.toList());
    }

    /**
     * 集合去重
     */
    private static List<User> distinct(List<User> userList) {
        return userList.stream().distinct().collect(Collectors.toList());
    }

    /**
     * 排序
     */
    private static List<User> sort(List<User> userList) {
        userList.sort(Comparator.comparing(User::getScore));
        return userList;
    }

    /**
     * 操作属性
     */
    private static List<Integer> doScore(List<User> userList) {
        return userList.stream().map(User::getScore).map(i -> i - 10).collect(Collectors.toList());
    }

    /**
     * 计算最高分
     */
    private static Integer getMaxScore(List<User> userList) {
        return userList.stream().map(User::getScore).reduce(Integer::max).get();
    }

    /**
     * 计算最低分
     */
    private static Integer getMinScore(List<User> userList) {
        return userList.stream().map(User::getScore).reduce(Integer::min).get();
    }

    /**
     * 计算总分
     */
    private static Integer getTotalScore(List<User> userList) {
        return userList.stream().map(User::getScore).reduce(0, Integer::sum);
    }

    /**
     * 计算平均分
     */
    private static Double getAvgScore(List<User> userList) {
        return userList.stream().mapToInt(User::getScore).average().getAsDouble();
    }

    /**
     * 清空对象list集合中的某个属性的值并返回结果
     */
    private static List<User> cleanBy(List<User> userList) {
        return userList.stream().peek(user -> user.setScore(0)).collect(Collectors.toList());
    }

    /**
     * 获取list集合中前三个元素 组成新的集合
     */
    private static List<User> getLimit(List<User> userList) {
        return userList.stream().limit(3).collect(Collectors.toList());
    }

    /**
     * 跳过list集合中前三个元素 剩余的元素组成新的集合
     */
    private static List<User> skip(List<User> userList) {
        return userList.stream().skip(3).collect(Collectors.toList());
    }

    /**
     * groupBy分组
     */
    private static Map<String, List<User>> groupBy(List<User> userList) {
        return userList.stream().collect(Collectors.groupingBy(User::getName));
    }

    /**
     * distinct去重
     */
    private static List<User> distinctList(List<User> userList) {
        return userList.stream().distinct().collect(Collectors.toList());
    }


}
